﻿import caurina.transitions.Tweener;

class PanelZoom extends MovieClip {
	var contenido:MovieClip;
	var mascara:MovieClip;
	var arrastre:MovieClip;
	var ejex:Number;
	var ejey:Number;
	var x0:Number;
	var y0:Number;
	var w0:Number;
	var h0:Number;
	var w_ini:Number;
	var h_ini:Number;
	var _secuenciador:Secuenciador;
	var _secuenciador2:Secuenciador2;
	var _secuenciador3:Secuenciador3;
	var _estable:Boolean;
	
	function PanelZoom() {
		_estable = true;
		inicializar();
	}
	
	function inicializar() {
		_secuenciador = new Secuenciador(this);
		_secuenciador2 = new Secuenciador2(this);
		_secuenciador3 = new Secuenciador3(this);
	}
	
	function onLoad() {
		contenido = this["contenido"];
		mascara = this["mascara"];
		arrastre = this["arrastre"];
		x0 = mascara._x;
		y0 = mascara._y;
		w0 = mascara._width;
		h0 = mascara._height;
		ejex = (mascara._x + mascara._width) / 2;
		ejey = (mascara._y + mascara._height) / 2;
		
		trace(_secuenciador);
		
		this["zoom_in"].onPress = function() {
			trace("zoom_in " + (this)._parent._secuenciador);
			_parent._secuenciador.z_in = true;
			_parent._secuenciador.ini_mov();
		}
		
		this["zoom_in"].onRelease = this["zoom_out"].onReleaseOutside = function() {
			_parent._secuenciador.fin_mov();
		}
		
		
		this["zoom_out"].onPress = function() {
			_parent._secuenciador.z_in = false;
			_parent._secuenciador.ini_mov();
		}
		
		this["zoom_out"].onRelease = this["zoom_out"].onReleaseOutside = function() {
			_parent._secuenciador.fin_mov();
		}
		
		this["pan"].onPress = function() {
			_parent._secuenciador.z_in = false;
			_parent._secuenciador.ini_mov();
			//_parent._secuenciador.pan();
		}
		
		arrastre.onPress = function() {
			/*
			var w1 = _parent.contenido._width;
			var h1 = _parent.contenido._height;
			var x_ini, x_fin, y_ini, y_fin:Number;
			if(w1>_parent.w0) {
				x_ini = _parent.x0+_parent.w0-w1;
				x_fin = _parent.x0;
			}
			else {
				x_ini = x_fin = _parent.contenido._x;
			}
			if(h1>_parent.h0) {
				y_ini = _parent.y0+_parent.h0-h1;
				y_fin = _parent.y0;
			}
			else {
				y_ini = y_fin = _parent.contenido._y;
			}
			_parent.contenido.startDrag(false, x_ini, y_ini, x_fin, y_fin);
			*/
			trace("arrastre ");
			_parent._secuenciador3.ini_mov();
		}
		
		arrastre.onRelease = arrastre.onReleaseOutside = function() {
			//_parent.contenido.stopDrag();
			_parent._secuenciador3.fin_mov();
		}
		
		this["izquierda"].onPress = this["derecha"].onPress =
		this["arriba"].onPress = this["abajo"].onPress = function() {
			if(this._name=="derecha")
				_parent._secuenciador2.dir = 1;
			else if(this._name=="izquierda")
				_parent._secuenciador2.dir = 2;
			else if(this._name=="arriba")
				_parent._secuenciador2.dir = 3;
			else if(this._name=="abajo")
				_parent._secuenciador2.dir = 4;

			_parent._secuenciador2.ini_mov();
		}
		
		this["izquierda"].onRelease = this["izquierda"].onReleaseOutside =
		this["derecha"].onRelease = this["derecha"].onReleaseOutside =
		this["arriba"].onRelease = this["arriba"].onReleaseOutside =
		this["abajo"].onRelease = this["abajo"].onReleaseOutside = function() {
			_parent._secuenciador2.fin_mov();
		}
		
		
	}
	
	function zoom_in() {
		if(!_estable)
			return;
		var escala = contenido._xscale * 1.5;
		Tweener.addTween(contenido, {_xscale: escala, _yscale: escala, delay: 0, time: 2, transition: "easeOutQuart"});
	}
	
	function zoom_out() {
		if(!_estable)
			return;
		var escala = contenido._xscale * 0.666666666666;
		Tweener.addTween(contenido, {_xscale: escala, _yscale: escala, delay: 0, time: 2, transition: "easeOutQuart"});
	}
	
	function set_estable(estable:Boolean) {
		_estable = estable;
	}
	
	function notif_cambio_contenido() {
		/* Como no se determinó con certeza cuál es el estado correcto pos cambio de imágenes
		 * se reinicializa todo
		 */
		//inicializar();
		//onLoad();
		/* toma del ancho y alto actuales, con las que lo entrega el módulo
		 * cargador de imágenes (externo a esta lógica)
		 * como precondición se asume que el módulo externo cargador de imágenes
		 * centra el contenido en el medio de la máscara (horizontal y vertical)
		 */
		w_ini = contenido._width;
		h_ini = contenido._height;
		_secuenciador.esc = 1;
		_estable = true;
	}
	
	function zoom(escala) {
		if(!_estable)
			return;
		trace("zoom " + escala);
		/* Lógica obsoleta
		 * detección de imagenes cargadas dinámicamente que reemplazan a otra imagen
		 * dentro del mismo objeto "contenido", por medio de una variable
		 *if(contenido["ini_zoom"]==undefined) {
		 *	contenido["ini_zoom"] = 1;
		 *	w_ini = contenido._width;
		 *	h_ini = contenido._height;
		 *}
		 */
	
		if(escala<1 || escala>3)
			return;
		var x1:Number = contenido._x;
		var y1:Number = contenido._y;
		var w1:Number = contenido._width;
		var h1:Number = contenido._height;
		
		// Obtención del ancho y alto escalados a partir del ancho y alto original de la imagen,
		// No sirve en contextos donde la imagen es adaptada a un área al ser cargada
		//var w2:Number = contenido._width/contenido._xscale*100*escala;
		//var h2:Number = contenido._height/contenido._yscale*100*escala;
		
		//Misma obtención del ancho y alto escalados, con un método
		// sin las desventajas del anterior
		var w2:Number = w_ini * escala;
		var h2:Number = h_ini * escala;
		
		var x2:Number;
		if(w2>w0) {
			x2 = ejex - (ejex-x1) / w1 * w2;
			x2 = Math.max(x0+w0-w2, Math.min(x2, x0));
		}
		else {
			x2 = (w0 - w2) / 2;
		}
		var y2:Number;
		if(h2>h0) {
			y2 = ejey - (ejey-y1) / h1 * h2;
			y2 = Math.max(y0+h0-h2, Math.min(y2, y0));
		}
		else {
			y2 = (h0 - h2) / 2;
		}
		trace(x0 + " " + y0 + " " + w0 + " " + h0 + " " + x1 + " " + y1 + " " + w1 + " " + h1);
		
		contenido._x = x2;
		contenido._y = y2;
		contenido._width = w2;
		contenido._height = h2;
		//Tweener.addTween(contenido, {_x: x2, _y: y2, _width: w2, _height: h2, delay: 0, time: 2, transition: "easeOutQuart"});		
	}
	
	function desplazar(movimiento:Object) {
		if(!_estable)
			return;
		if(movimiento.x!=undefined) {
			var w1 = contenido._width;
			var x;
			if(w1>w0)
				x= Math.max(x0+w0-w1, Math.min(contenido._x+movimiento.x, x0));
			else
				x = contenido._x;
			contenido._x = x;
		}
		if(movimiento.y!=undefined) {
			var h1 = contenido._height;
			var y;
			if(h1>h0)
				y = Math.max(y0+h0-h1, Math.min(contenido._y+movimiento.y, y0));
			else
				y = contenido._y;
			contenido._y = y;
		}
	}
}